// { dg-do compile { target c++11 } }

typedef enum omp_allocator_handle_t
: __UINTPTR_TYPE__
{
  omp_null_allocator = 0,
  omp_default_mem_alloc = 1,
  omp_large_cap_mem_alloc = 2,
  omp_const_mem_alloc = 3,
  omp_high_bw_mem_alloc = 4,
  omp_low_lat_mem_alloc = 5,
  omp_cgroup_mem_alloc = 6,
  omp_pteam_mem_alloc = 7,
  omp_thread_mem_alloc = 8,
  __omp_allocator_handle_t_max__ = __UINTPTR_MAX__
} omp_allocator_handle_t;

typedef enum omp_sync_hint_t {
omp_sync_hint_none = 0x0,
omp_lock_hint_none = omp_sync_hint_none,
omp_sync_hint_uncontended = 0x1,
omp_lock_hint_uncontended = omp_sync_hint_uncontended,
omp_sync_hint_contended = 0x2,
omp_lock_hint_contended = omp_sync_hint_contended,
omp_sync_hint_nonspeculative = 0x4,
omp_lock_hint_nonspeculative = omp_sync_hint_nonspeculative,
omp_sync_hint_speculative = 0x8,
omp_lock_hint_speculative = omp_sync_hint_speculative
} omp_sync_hint_t;

typedef struct __attribute__((__aligned__ (sizeof (void *)))) omp_depend_t {
  char __omp_depend_t__[2 * sizeof (void *)];
} omp_depend_t;

int t;
#pragma omp threadprivate (t)

#pragma omp declare target
int f, l, ll, r, r2;

void
foo (int d, int m, int i1, int i2, int p, int *idp, int s,
     int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm)
{
  [[omp::directive (distribute parallel for
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) order(concurrent) allocate (omp_default_mem_alloc:f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute parallel for simd
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    if (parallel: i2) if(simd: i1) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) nontemporal(ntm)
    safelen(8) simdlen(4) aligned(q: 32) order(concurrent) allocate (omp_default_mem_alloc:f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute simd
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    safelen(8) simdlen(4) aligned(q: 32) reduction(+:r) if(i1) nontemporal(ntm)
    order(concurrent) allocate (omp_default_mem_alloc:f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    allocate (omp_default_mem_alloc:f) order(concurrent))]]
  for (int i = 0; i < 64; i++)
    ll++;
}

void
qux (int p)
{
  [[omp::directive (loop bind(teams) order(concurrent)
    private (p) lastprivate (l) collapse(1) reduction(+:r))]]
  for (l = 0; l < 64; ++l)
    ll++;
}
#pragma omp end declare target

void
baz (int d, int m, int i1, int i2, int p, int *idp, int s,
     int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm)
{
  [[omp::directive (distribute parallel for
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) copyin(t) allocate (p))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute parallel for
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) order(concurrent) allocate (p))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute parallel for simd
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    if (parallel: i2) if(simd: i1) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) nontemporal(ntm)
    safelen(8) simdlen(4) aligned(q: 32) copyin(t) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute parallel for simd
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    if (parallel: i2) if(simd: i1) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) nontemporal(ntm)
    safelen(8) simdlen(4) aligned(q: 32) order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute simd
    private (p) firstprivate (f) collapse(1) dist_schedule(static, 16)
    safelen(8) simdlen(4) aligned(q: 32) reduction(+:r) if(i1) nontemporal(ntm)
    order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (loop bind(parallel) order(concurrent)
    private (p) lastprivate (l) collapse(1) reduction(+:r))]]
  for (l = 0; l < 64; ++l)
    ll++;
}

void
bar (int d, int m, int i1, int i2, int i3, int p, int *idp, int hda, int s,
     int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int *dd, int ntm,
     const char *msg)
{
  [[omp::directive (nothing)]];
  [[omp::directive (error at (execution) severity (warning) message (msg))]];
  [[omp::directive (for simd
    private (p) firstprivate (f) lastprivate (l) linear (ll:1) reduction(+:r) schedule(static, 4) collapse(1) nowait
    safelen(8) simdlen(4) aligned(q: 32) nontemporal(ntm) if(i1) order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (for
    private (p) firstprivate (f) lastprivate (l) linear (ll:1) reduction(+:r) schedule(static, 4) collapse(1) nowait
    order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (simd
    private (p) lastprivate (l) linear (ll:1) reduction(+:r) collapse(1) safelen(8) simdlen(4) aligned(q: 32)
    nontemporal(ntm) if(i1) order(concurrent))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel for
    private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) linear (ll:1) ordered schedule(static, 4) collapse(1) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel for
    private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1) order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel for simd
    private (p) firstprivate (f) if (i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1)
    safelen(8) simdlen(4) aligned(q: 32) nontemporal(ntm) order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel sections
    private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) allocate (f))]]
  {
    [[omp::directive (section)]]
    {}
    [[omp::sequence (omp::directive (section))]]
    {}
  }
  [[omp::directive (sections private (p) firstprivate (f) reduction(+:r) lastprivate (l) allocate (f) nowait)]]
  {
    ;
    [[omp::sequence (sequence (directive (section)))]]
    ;
    [[omp::directive (section)]]
    {}
  }
  [[omp::directive (barrier)]];
  [[omp::sequence (omp::directive (single private (p) firstprivate (f) allocate (f) nowait))]]
    ;
  [[omp::sequence (directive (barrier))]];
  [[omp::sequence (directive (parallel private (p)),
    omp::directive (single copyprivate (p) firstprivate (f) allocate (f)))]]
    p = 6;
  [[omp::directive (target parallel
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    nowait depend(inout: dd[0]) allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]]
    ;
  [[omp::directive (target parallel for
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) linear (ll:1) ordered schedule(static, 4) collapse(1) nowait depend(inout: dd[0])
    allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (target parallel for
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1) nowait depend(inout: dd[0]) order(concurrent)
    allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (target parallel for simd
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1)
    safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0]) nontemporal(ntm) if (simd: i3) order(concurrent)
    allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (target teams
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl) nowait depend(inout: dd[0])
    allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda)))]]
    ;
  [[omp::sequence (directive (target
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    nowait depend(inout: dd[0]) allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda)))]]
    ;
  [[omp::sequence (omp::directive (target teams distribute
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) order(concurrent)
    collapse(1) dist_schedule(static, 16) nowait depend(inout: dd[0]) allocate (omp_default_mem_alloc:f) in_reduction(+:r2)
    has_device_addr (hda)))]]
  for (int i = 0; i < 64; i++)
    ;
  [[omp::directive (target teams distribute parallel for
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16)
    if (parallel: i2) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) nowait depend(inout: dd[0]) order(concurrent)
     allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (target teams distribute parallel for simd
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16)
    if (parallel: i2) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) order(concurrent)
    safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0]) nontemporal(ntm) if (simd: i3)
    allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (target teams distribute simd
    device(d) map (tofrom: m) if (i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16) order(concurrent)
    safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0]) nontemporal(ntm)
    allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (target simd
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    safelen(8) simdlen(4) lastprivate (l) linear(ll: 1) aligned(q: 32) reduction(+:r)
    nowait depend(inout: dd[0]) nontemporal(ntm) if(simd:i3) order(concurrent)
    allocate (omp_default_mem_alloc:f) in_reduction(+:r2) has_device_addr (hda))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup task_reduction(+:r2) allocate (r2)),
    omp::directive (taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) if(simd: i2) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm)
    order(concurrent) allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (taskgroup task_reduction(+:r) allocate (r)),
    directive (taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(i1) final(fi) mergeable nogroup priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) in_reduction(+:r) nontemporal(ntm)
    order(concurrent) allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (taskwait)]];
  [[omp::directive (taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) if(taskloop: i1) final(fi) priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(+:r) if (simd: i3) nontemporal(ntm)
    order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup task_reduction(+:r2) allocate (r2)),
    omp::directive (taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) in_reduction(+:r2) allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup task_reduction(+:r2) allocate (r2)),
    omp::directive (task
    private (p) firstprivate (f) shared (s) default(shared) untied if(task: i1) final(fi) mergeable priority (pp)
    in_reduction(+:r2) allocate (f)))]]
    ;
  [[omp::directive (taskyield)]];
  [[omp::directive (target data if (target data: i1) device(d) map (tofrom: m) use_device_ptr (q) use_device_addr (p))]]
  ;
  [[omp::directive (target enter data if (target enter data: i1) device(d) map (to: m) depend(inout: dd[0]) nowait)]]
  ;
  [[omp::directive (target exit data if (target exit data: i1) device(d) map (from: m) depend(inout: dd[0]) nowait)]]
  ;
  [[omp::directive (target update if (target update: i1) device(d) to (m) depend(inout: dd[0]) nowait)]]
  ;
  [[omp::directive (target update if (target update: i1) device(d) from (m) depend(inout: dd[0]) nowait)]]
  ;
  [[omp::directive (taskwait)]];
  [[omp::sequence (directive (target nowait depend(inout: dd[0]) in_reduction(+:r2)),
    directive (teams distribute
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16) allocate (omp_default_mem_alloc: f) order(concurrent)))]]
  for (int i = 0; i < 64; i++)
    ;
  [[omp::directive (teams
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl)
    allocate (omp_default_mem_alloc: f))]]
    ;
  [[omp::sequence (omp::directive (target),
    omp::directive (teams distribute parallel for
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16)
    if (parallel: i2) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) order(concurrent) allocate (omp_default_mem_alloc: f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (target),
    directive (teams distribute parallel for simd
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16)
    if (parallel: i2) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) order(concurrent)
    safelen(8) simdlen(4) aligned(q: 32) if (simd: i3) nontemporal(ntm)
    allocate (omp_default_mem_alloc: f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (target),
    directive (teams distribute simd
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16) order(concurrent)
    safelen(8) simdlen(4) aligned(q: 32) if(i3) nontemporal(ntm)
    allocate (omp_default_mem_alloc: f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute parallel for
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16)
    if (parallel: i2) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) copyin(t) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute parallel for
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16) order(concurrent)
    if (parallel: i2) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute parallel for simd
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16)
    if (parallel: i2) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4)
    safelen(8) simdlen(4) aligned(q: 32) if (simd: i3) nontemporal(ntm) copyin(t)
    allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute parallel for simd
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16)
    if (parallel: i2) num_threads (nth) proc_bind(spread)
    lastprivate (l) schedule(static, 4) order(concurrent)
    safelen(8) simdlen(4) aligned(q: 32) if (simd: i3) nontemporal(ntm)
    allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute simd
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte-1:nte) thread_limit(tl)
    collapse(1) dist_schedule(static, 16) order(concurrent)
    safelen(8) simdlen(4) aligned(q: 32) if(i3) nontemporal(ntm) allocate(f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master
    private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) reduction(+:r)
    num_threads (nth) proc_bind(spread) copyin(t) allocate (f))]]
    ;
  [[omp::directive (parallel masked
    private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) reduction(+:r)
    num_threads (nth) proc_bind(spread) copyin(t) allocate (f) filter (d))]]
    ;
  [[omp::directive (parallel
    private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) reduction(+:r)
    num_threads (nth) proc_bind(spread) copyin(t) allocate (f))]]
    ;
  [[omp::sequence (directive (taskgroup task_reduction (+:r2) allocate (r2)),
    omp::directive (master taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) in_reduction(+:r2) allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup task_reduction (+:r2) allocate (r2)),
    omp::directive (masked taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) in_reduction(+:r2) allocate (f) filter (d)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (master)]];
  [[omp::directive (masked)]];
  [[omp::directive (masked filter (d))]];
  [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2) allocate (r2)),
    directive (master taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) if(simd: i2) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm)
    order(concurrent) allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2) allocate (r2)),
    directive (masked taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) if(simd: i2) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm)
    order(concurrent) allocate (f) filter (d)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) if (parallel: i2) num_threads (nth) proc_bind(spread) copyin(t) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel masked taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) if (parallel: i2) num_threads (nth) proc_bind(spread) copyin(t) allocate (f) filter (d))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) if(simd: i2) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) nontemporal(ntm) if (parallel: i2) num_threads (nth) proc_bind(spread) copyin(t)
    order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel masked taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) grainsize (g) collapse(1) untied if(taskloop: i1) if(simd: i2) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) nontemporal(ntm) if (parallel: i2) num_threads (nth) proc_bind(spread) copyin(t)
    order(concurrent) allocate (f) filter (d))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup task_reduction (+:r2) allocate (r2)),
    directive (master taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) in_reduction(+:r2)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup task_reduction (+:r2) allocate (r2)),
    directive (masked taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) in_reduction(+:r2) filter (d)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2) allocate (r2)),
    omp::directive (master taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm)
    order(concurrent) allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2) allocate (r2)),
    omp::directive (masked taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) in_reduction(+:r2) nontemporal(ntm)
    order(concurrent) allocate (f) filter (d)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) num_threads (nth) proc_bind(spread) copyin(t) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel masked taskloop
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp)
    reduction(default, +:r) num_threads (nth) proc_bind(spread) copyin(t) allocate (f) filter (d))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) nontemporal(ntm) num_threads (nth) proc_bind(spread) copyin(t)
    order(concurrent) allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel masked taskloop simd
    private (p) firstprivate (f) lastprivate (l) shared (s) default(shared) num_tasks (nta) collapse(1) untied if(i1) final(fi) mergeable priority (pp)
    safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(default, +:r) nontemporal(ntm) num_threads (nth) proc_bind(spread) copyin(t)
    order(concurrent) allocate (f) filter (d))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (loop bind(thread) order(concurrent)
    private (p) lastprivate (l) collapse(1) reduction(+:r))]]
  for (l = 0; l < 64; ++l)
    ll++;
  [[omp::directive (parallel loop
    private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) collapse(1) bind(parallel) order(concurrent) allocate (f))]]
  for (l = 0; l < 64; l++)
    ll++;
  [[omp::directive (parallel loop
    private (p) firstprivate (f) if (parallel: i2) default(shared) shared(s) copyin(t) reduction(+:r) num_threads (nth) proc_bind(spread)
    lastprivate (l) collapse(1) allocate (f))]]
  for (l = 0; l < 64; l++)
    ll++;
  [[omp::directive (teams loop
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl)
    collapse(1) lastprivate (l) bind(teams) allocate (f))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (teams loop
    private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte - 1:nte) thread_limit(tl)
    collapse(1) lastprivate (l) order(concurrent) allocate (f))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (target parallel loop
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    nowait depend(inout: dd[0]) lastprivate (l) bind(parallel) order(concurrent) collapse(1)
    allocate (omp_default_mem_alloc: f) in_reduction(+:r2) has_device_addr (hda))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (target parallel loop
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
    nowait depend(inout: dd[0]) lastprivate (l) order(concurrent) collapse(1)
    allocate (omp_default_mem_alloc: f) in_reduction(+:r2) has_device_addr (hda))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (target teams loop
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) nowait depend(inout: dd[0])
    lastprivate (l) bind(teams) collapse(1)
    allocate (omp_default_mem_alloc: f) in_reduction(+:r2) has_device_addr (hda))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (target teams loop
    device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp)
    shared(s) default(shared) reduction(+:r) num_teams(nte - 1 : nte) thread_limit(tl) nowait depend(inout: dd[0])
    lastprivate (l) order(concurrent) collapse(1)
    allocate (omp_default_mem_alloc: f) in_reduction(+:r2) has_device_addr (hda))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (critical)]] {
  }
  [[omp::directive (critical (foobar) hint(omp_sync_hint_none))]]
  ;
  [[omp::directive (taskwait depend (inout: dd[0]))]]
  ;
  [[omp::directive (taskgroup task_reduction(+:r2) allocate (r2))]]
  ;
  [[omp::directive (atomic update seq_cst hint(omp_sync_hint_none))]]
  p++;
  [[omp::directive (atomic read hint(omp_sync_hint_none) relaxed)]]
  f = p;
  [[omp::directive (atomic write release hint(omp_sync_hint_none))]]
  p = f;
  [[omp::directive (flush)]]
  ;
  [[omp::directive (flush acq_rel)]]
  ;
  [[omp::directive (flush acquire)]]
  ;
  [[omp::directive (flush release)]]
  ;
  [[omp::directive (flush seq_cst)]]
  ;
  [[omp::directive (flush (p, f))]]
  ;
  [[omp::directive (simd
    private (p) lastprivate (l) linear (ll:1) reduction(+:r) collapse(1) safelen(8) simdlen(4) aligned(q: 32)
    nontemporal(ntm) if(i1))]]
  for (int i = 0; i < 64; i++)
    [[omp::directive (ordered simd)]]
      ll++;
  [[omp::directive (for
    private (p) firstprivate (f) lastprivate (l) linear (ll:1) reduction(+:r) schedule(static, 4) collapse(1) nowait
    ordered allocate (f))]]
  for (int i = 0; i < 64; i++)
    [[omp::directive (ordered threads)]]
      ll++;
  [[omp::directive(for ordered (1))]]
  for (l = 0; l < 64; l++)
    {
      [[omp::directive(ordered depend (sink: l - 1))]];
      [[omp::directive(ordered depend (source))]];
    }
  extern omp_depend_t depobj;
  [[omp::directive (depobj(depobj) depend(in : dd[0]))]];
  [[omp::directive (parallel)]] {
    if (p) {
      [[omp::directive (cancel parallel)]];
    } else {
      [[omp::directive (cancellation point parallel)]];
    }
  }
  [[omp::directive (scope private (p) reduction(+:r) nowait)]]
    ;
  [[omp::directive (scope private (p) reduction(task, +:r))]]
    ;
  extern int t2;
  [[omp::directive (threadprivate (t2))]];
  extern int t2;
  [[omp::directive (declare reduction (dr: int: omp_out += omp_in) initializer (omp_priv = 0))]]
  ;
  [[omp::directive (parallel)]]
  if (0)
    ;
  [[omp::directive (parallel)]]
  while (0)
    ;
  [[omp::directive (parallel)]]
  switch (0) { case 1: break; default: break; }
}

void corge1 ();

void
corge ()
{
  [[omp::directive (declare variant (corge1) match (construct={parallel,for}))]]
  extern void corge2 ();
  [[omp::sequence (directive (parallel), directive (for))]]
  for (int i = 0; i < 5; i++)
    corge2 ();
  [[omp::directive (declare simd simdlen(4) linear(l) aligned(p:4) uniform(p) inbranch),
    omp::directive (declare simd simdlen(8) notinbranch)]]
  extern int corge3 (int l, int *p);
  [[omp::directive (declare simd simdlen(4) linear(l) aligned(p:4) uniform(p) inbranch),
    omp::directive (declare simd simdlen(8) notinbranch)]]
  extern int corge4 (int l, int *p);
  [[omp::sequence (directive (declare simd simdlen(4) linear(l) aligned(p:4) uniform(p) inbranch),
    omp::directive (declare simd simdlen(8) notinbranch))]]
  extern int corge5 (int l, int *p);
  [[omp::directive (declare target)]];
  extern void corge6 ();
  [[omp::directive (end declare target)]];
}

int
garply (int a, int *c, int *d, int *e, int *f)
{
  int i;
  [[omp::directive (simd reduction (inscan, +: a))]]
  for (i = 0; i < 64; i++)
    {
      d[i] = a;
      [[omp::directive (scan exclusive (a))]]
      a += c[i];
    }
  [[omp::directive (simd reduction (inscan, +: a))]]
  for (i = 0; i < 64; i++)
    {
      a += c[i];
      [[omp::sequence (omp::sequence (omp::directive (scan inclusive (a))))]]
      d[i] = a;
    }
  return a;
}
